Управляющие конструкции и циклы в PHP

ОБЯЗАТЕЛЬНОДЛЯ НОВИЧКОВ

Разработчику Архитектору

Операторы и циклы

PHP предоставляет полный набор управляющих конструкций, позволяющих строить сложную логику выполнения программ. Эти конструкции делятся на две большие группы: условные (ветвление) и циклические (повторение). Внутри этих групп реализованы как классические операторы (if, for), так и современные языковые возможности (match, генераторы).

Все управляющие конструкции работают с выражениями, результат которых интерпретируется в логическом контексте. В PHP любое значение может быть преобразовано к булевому типу по правилам неявного приведения: например, 0, '', [], null, false считаются ложными, всё остальное — истинным.

---

Условные конструкции

Конструкция if

Конструкция if позволяет выполнять блок кода только при истинности заданного условия. Алгоритм работы строится на проверке логического выражения, которое может принимать значение истинно или ложно.

Синтаксис конструкции состоит из ключевого слова if, за которым следует условие в круглых скобках, а затем блок кода в фигурных скобках. Если условие возвращает значение истинно, код внутри блока выполняется. Если условие ложно, блок пропускается, и выполнение продолжается с инструкции, следующей за всей конструкцией.

if (<условие>) {
    // выполняется, если условие истинно
} elseif (<другое_условие>) {
    // выполняется, если предыдущее ложно, а это — истинно
} else {
    // выполняется, если все условия ложны
}

Для обработки нескольких взаимозависимых ситуаций используется конструкция с ветвлением. Ключевое слово elseif добавляет возможность проверить альтернативное условие, если предыдущее оказалось ложным. Ключевое слово else охватывает все случаи, когда ни одно из предыдущих условий не выполнилось.

<?php
$temperature = 22;

if ($temperature > 30) {
    echo "Жарко";
} elseif ($temperature > 20) {
    echo "Комфортно";
} elseif ($temperature > 10) {
    echo "Прохладно";
} else {
    echo "Холодно";
}

В данном случае переменная хранит значение 22. Условие проверяет, больше ли это число 30. Результат проверки — ложь, поэтому текст «Жарко» не выводится на экран.

Конструкция поддерживает неограниченное количество веток elseif. Проверка условий происходит строго сверху вниз. Первое истинное условие определяет выполняемый блок; остальные игнорируются.

При работе с данными, поступающими извне, такими как параметры запроса $_GET или данные формы, необходимо строго контролировать их тип и содержание. Неявное приведение типов в PHP может привести к неожиданным результатам и уязвимостям безопасности.

Функция filter_input предназначена для безопасного получения и фильтрации входных данных. Она принимает имя типа источника данных, имя переменной и константу фильтра. В примере используется фильтр FILTER_VALIDATE_INT для проверки того, является ли введенное значение целым числом.

$id = filter_input(INPUT_GET, 'id', FILTER_VALIDATE_INT);

Если параметр id отсутствует или не является числом, функция вернет false. Если параметр существует и корректен, она вернет само число.

Проверка результата должна включать два аспекта: наличие значения и его соответствие требованиям. Использование оператора строгости !== гарантирует, что false не будет автоматически преобразовано в 0 или другую допустимую величину.

if ($id !== false && $id > 0) {
    loadItem($id);
}

Условие $id !== false подтверждает, что данные были успешно получены и имеют правильный тип. Условие $id > 0 гарантирует, что идентификатор положительный, так как отрицательные или нулевые значения часто недопустимы для поиска записи в базе данных. Только при одновременном выполнении обоих условий вызывается функция загрузки элемента.

Такой подход исключает ошибки, возникающие при сравнении пустых строк, нулей или других некорректных значений с числами. Строгая проверка типов делает код предсказуемым и защищенным от атак, связанных с подменой параметров.

---

Альтернативный синтаксис шаблонов

В HTML-шаблонах допустим альтернативный синтаксис, повышающий читаемость:

<?php if (<условие>): ?>
    <!-- HTML -->
<?php elseif (<условие>): ?>
    <!-- другой HTML -->
<?php else: ?>
    <!-- резервный HTML -->
<?php endif; ?>

<?php if ($isLoggedIn): ?>
    <div>Привет, <?= htmlspecialchars($user) ?>!</div>
<?php else: ?>
    <form method="post" action="/login">
        <input name="user">
        <button>Войти</button>
    </form>
<?php endif; ?>

Этот стиль применяется только в смешанных файлах (HTML + PHP). В чистом коде используется фигурный синтаксис.

---

Конструкция switch

Конструкция switch сравнивает выражение с набором значений и выполняет соответствующий блок кода.

Алгоритм работы строится на последовательном переборе случаев до тех пор, пока не будет найдено подходящее значение или не будет достигнут конец конструкции.

Синтаксис конструкции начинается с ключевого слова switch, за которым следует выражение в круглых скобках. Далее следуют блоки case, каждый из которых содержит одно из возможных значений для сравнения. После каждого значения ставит двоеточие, а затем идет блок кода, который должен выполниться при совпадении. Завершается конструкция блоком default, который выполняется, если ни один из предыдущих случаев не подошел.

switch (<выражение>) {
    case <значение1>:
        // действия
        break;
    case <значение2>:
        // действия
        break;
    default:
        // действия по умолчанию
}

<?php
$status = 404;

switch ($status) {
    case 200:
        echo "OK";
        break;
    case 404:
        echo "Страница не найдена";
        break;
    case 500:
        echo "Ошибка сервера";
        break;
    default:
        echo "Неизвестный статус";
}

В данном примере переменная $status хранит число 404. Система сравнивает это значение с каждым из условий case. Первое условие (200) не совпадает. Второе условие (404) совпадает. Скрипт выполняет код внутри этого блока, выводя текст «Страница не найдена». Затем выполнение переходит к инструкции, следующей за всей конструкцией switch.

Ключевой особенностью конструкции switch является использование оператора слабого сравнения (==). Это означает, что PHP автоматически приводит типы данных к общему виду перед проверкой равенства. Строка '2' считается равной числу 2. Число true равно 1, а false равно 0. Такое поведение позволяет упростить запись кода, но требует внимательности при работе со смешанными типами данных.

Каждая ветка case должна завершаться инструкцией break. Эта команда принудительно прерывает выполнение цикла switch и передает управление дальше по потоку программы. Если инструкция break отсутствует, происходит так называемое проваливание (fall-through). Выполнение продолжается в следующем блоке case, независимо от того, совпадает ли его значение с исходным выражением.

Особенности switch:

• Использует слабое сравнение (==). Это означает, что '2' == 2 — true.
• Требует явного указания break в конце каждой ветки. Без него выполнение «проваливается» в следующую ветку.
• Поддерживает ветку default для обработки всех остальных случаев.
• Может содержать составные инструкции: переменные, циклы, вызовы функций.

Пример проваливания:

switch ($role) {
    case 'admin':
        grantFullAccess();
        // нет break — продолжаем
    case 'editor':
        grantEditAccess();
        break;
    default:
        grantReadAccess();
}

При значении роли 'admin' система сначала выполняет функцию предоставления полного доступа. Поскольку после этого блока нет команды break, выполнение не останавливается, а переходит к следующему случаю case 'editor'. Там вызывается функция предоставления прав редактора. Только после нее встречается break, который завершает работу конструкции. В результате пользователь получает права администратора и редактора одновременно.

Такой паттерн иногда используется намеренно для объединения логики нескольких случаев. Например, если права администратора должны включать в себя все права редактора, можно опустить break после случая администратора. Однако этот подход снижает читаемость кода и повышает риск ошибок. При использовании такого метода необходимо оставлять подробные комментарии, объясняющие причину отсутствия инструкции break.

Ветка default служит запасным вариантом обработки. Она выполняется, если ни одно из условий case не дало положительного результата. Эта ветка не обязательно должна быть последней, но стандартная практика предполагает ее размещение в конце конструкции. Если default стоит перед другими случаями, она также будет работать как точка входа, если совпадение не найдено, но порядок проверки остается строгим сверху вниз.

Внутри блоков case разрешается размещать любые допустимые инструкции PHP. Это могут быть присваивания переменных, циклы, вызовы функций, условные операторы if и другие конструкции. Главное требование — корректное завершение каждой ветки командой break (если проваливание не запланировано) или явное завершение работы конструкции.

Пример использования составной инструкции:

$action = 'delete';

switch ($action) {
    case 'create':
        $id = createRecord();
        if ($id > 0) {
            notifyUser($id);
        }
        break;
    case 'update':
        updateRecord($id);
        logChange();
        break;
    case 'delete':
        deleteRecord($id);
        logChange();
        break;
    default:
        echo "Неизвестное действие";
}

Здесь каждый случай содержит несколько строк кода, выполняющих комплексные операции. В случае создания записи проверяется результат функции createRecord, и только при успехе отправляется уведомление. Такой подход позволяет инкапсулировать сложную логику внутри одной структуры выбора, делая код более организованным по сравнению с использованием множества вложенных операторов if-elseif.

Конструкция switch эффективна при наличии большого количества фиксированных значений для проверки одного выражения. Она делает код более лаконичным и понятным, когда количество условий превышает три-четыре варианта. Для проверки диапазонов значений или сложных логических выражений конструкция if часто подходит лучше, так как switch работает только с точным совпадением (или слабым приведением типов).

Использование switch рекомендуется, когда нужно обработать множество дискретных состояний объекта, таких как HTTP-статусы, типы пользователей, режимы работы системы или коды ошибок. Структура обеспечивает четкую визуальную иерархию и упрощает навигацию по коду при большом количестве вариантов развития событий.

---

Оператор match (PHP 8.0+)

Оператор match — функциональная альтернатива switch. Он всегда возвращает значение, использует строгое сравнение (===) и не допускает проваливания.

$<результат> = match (<выражение>) {
    <значение1> => <результат1>,
    <значение2>, <значение3> => <результат2>,
    default => <резервный_результат>
};

<?php
$role = 'editor';
$label = match($role) {
    'admin' => 'Администратор',
    'editor' => 'Редактор',
    'user' => 'Пользователь',
    default => 'Гость'
};

// Сравнение нескольких значений
$message = match($code) {
    200, 201, 204 => 'Успех',
    400, 404 => 'Ошибка клиента',
    default => 'Неизвестно'
};

Преимущества match:

• Компактность и безопасность.
• Возможность использования внутри выражений.
• Гарантированное покрытие всех случаев (иначе — исключение UnhandledMatchError).

Ограничения:

• Каждая ветка — одно выражение, без составных инструкций.
• Не подходит для побочных эффектов (например, логирования).

---

Логические и тернарные операторы

Тернарный оператор

Тернарный оператор позволяет компактно записать простое условное присваивание.

$<результат> = <условие> ? <значение_если_истина> : <значение_если_ложь>;

$status = ($age >= 18) ? 'взрослый' : 'несовершеннолетний';

Сокращённая форма (Elvis operator):

$<результат> = <выражение> ?: <значение_по_умолчанию>;

$username = $_GET['user'] ?: 'Гость';

Здесь $username получит значение $_GET['user'], если оно истинно, иначе — 'Гость'.

---

Оператор null coalescing (??)

Оператор ?? проверяет значение на строгое равенство null.

$<результат> = $<возможно_null> ?? <значение_по_умолчанию>;

$page = $_GET['page'] ?? 1;

Если $_GET['page'] равно null, будет использовано 1. Значения 0, '0', '' считаются валидными и не заменяются.

Цепочка:

$value = $a ?? $b ?? $c ?? 'default';

---

Null coalescing assignment (??=)

Начиная с PHP 7.4:

$config['timeout'] ??= 30;

Эквивалентно:

$config['timeout'] = $config['timeout'] ?? 30;

---

Циклические конструкции

Цикл for

Цикл for используется, когда известно количество итераций или требуется числовая индексация.

Цикл for представляет собой механизм повторения выполнения блока кода, когда заранее известно количество необходимых итераций или требуется последовательная нумерация шагов. Этот инструмент идеально подходит для работы с массивами по индексу, перебора числовых диапазонов и реализации алгоритмов, зависящих от счетчика. Алгоритм работы строится на трех четко определенных этапах, которые выполняются в строгой последовательности до тех пор, пока условие истинно.

Синтаксис конструкции состоит из ключевого слова for, за которым следуют три выражения, разделенные точкой с запятой, и заключенные в круглые скобки. Затем идет блок кода в фигурных скобках, который будет выполняться многократно.

for ($<счётчик> = <начало>; $<счётчик> < <конец>; $<счётчик>++) {
    // тело цикла
}

Первое выражение — это инициализация. Оно выполняется один раз перед началом первого прохода цикла. В этой части обычно объявляется переменная-счетчик и присваивается ей начальное значение. Если переменная уже существует, инициализация может быть опущена или просто выполнена как присваивание.

Второе выражение — это условие завершения. Оно проверяется перед каждой итерацией. Система вычисляет логическое значение этого условия. Если результат истинен, выполняется тело цикла. Если результат ложен, цикл завершается, и управление передается следующей инструкции после всего блока for.

Третье выражение — это инкремент (или декремент). Оно выполняется сразу после завершения тела цикла, но перед следующей проверкой условия. Здесь обычно происходит изменение значения счетчика, например, его увеличение на единицу (++) или уменьшение (--). Это выражение готовит переменную к следующей проверке условия.

for ($i = 0; $i < 5; $i++) {
    echo "Итерация $i\n";
}

В этом примере инициализация устанавливает переменную $i в значение 0. Условие $i < 5 проверяет, меньше ли текущее значение 5. Поскольку 0 меньше 5, выполняется тело цикла, которое выводит текст «Итерация 0». После этого срабатывает инкремент $i++, увеличивающий переменную до 1. Проверка условия повторяется. Процесс продолжается до тех пор, пока $i не станет равным 5. При значении 5 условие $i < 5 возвращает ложь, и цикл останавливается.

Компоненты:

• Инициализация — один раз перед циклом.
• Условие — проверяется перед каждой итерацией.
• Инкремент — выполняется после каждой итерации.

Переменная цикла остаётся в области видимости после завершения.

Процесс работы цикла можно описать как замкнутый контур. Сначала система выполняет инициализацию. Затем она переходит к проверке условия. Если условие истинно, выполняется тело цикла. Сразу после этого выполняется выражение инкремента. После чего система снова возвращается к проверке условия. Этот цикл повторяется бесконечно, пока условие остается истинным.

Если условие изначально ложно (например, начальное значение больше предельного), тело цикла никогда не выполнится ни разу. Инициализация все равно произойдет, но проверка условия остановит выполнение до входа в блок кода.

Пример с обратным отсчетом демонстрирует использование декремента:

for ($j = 3; $j >= 0; $j--) {
    echo "Осталось секунд: $j\n";
}

Здесь инициализация ставит $j в 3. Условие $j >= 0 истинно. Выполняется вывод. Инкремент $j-- уменьшает значение до 2. Следующая проверка успешна. Цикл продолжается, пока $j не станет -1. При значении -1 условие $j >= 0 становится ложным, и цикл завершается.

Переменная, объявленная в части инициализации цикла for, имеет область видимости, ограниченную циклом. Однако в PHP поведение зависит от версии языка и контекста. В современных версиях PHP (7.0 и выше) переменная, объявленная внутри for, доступна только внутри тела цикла и не видна снаружи.

В более ранних версиях PHP или при использовании синтаксиса без объявления типа в некоторых случаях переменная могла оставаться доступной вне цикла. Для гарантированного контроля области видимости рекомендуется использовать современные стандарты кодирования. Если переменная нужна за пределами цикла, ее следует объявить до начала цикла или явно вывести за пределы конструкции.

Пример ограничения области видимости:

for ($k = 0; $k < 3; $k++) {
    echo "Внутри: $k\n";
}
// echo "$k"; // Ошибка: переменная $k не определена в этой области

В данном случае попытка обратиться к $k после цикла вызовет ошибку, так как переменная была создана только внутри структуры for и уничтожена после его завершения. Это свойство помогает избежать конфликтов имен и утечек памяти, сохраняя пространство имен чистым.

Конструкция for допускает сложную логику в каждом из трех компонентов. В части инициализации можно объявлять несколько переменных, разделяя их запятыми. В условии можно использовать сложные логические выражения с операторами &&, || и !. В выражении инкремента можно изменять сразу несколько переменных или выполнять функции.

Пример множественной инициализации и сложного инкремента:

for ($x = 0, $y = 10; $x < $y; $x++, $y--) {
    echo "X: $x, Y: $y\n";
}

Здесь две переменные $x и $y инициализируются одновременно. Условие проверяет, меньше ли $x чем $y. После каждой итерации обе переменные изменяются: $x увеличивается, а $y уменьшается. Цикл останавливается, когда $x достигает значения $y.

Такая гибкость позволяет реализовать сложные алгоритмы поиска, сортировки и обработки данных в компактной форме. Важно следить за тем, чтобы выражение инкремента гарантированно приближало условие к ложному значению, иначе цикл превратится в бесконечный.

---

Цикл while

Цикл while проверяет условие перед каждой итерацией.

Цикл while представляет собой механизм повторения выполнения блока кода, основанный на проверке условия перед началом каждого прохода. Этот инструмент предназначен для ситуаций, когда количество итераций заранее неизвестно или зависит от динамических изменений данных внутри тела цикла. Алгоритм работы строится на непрерывной проверке логического выражения: если оно истинно, выполняется код; если ложно — цикл завершается.

Синтаксис конструкции начинается с ключевого слова while, за которым следует условие в круглых скобках. После условия идет блок кода в фигурных скобках, который будет выполняться многократно.

while (<условие>) {
    // тело цикла
}

$count = 3;
while ($count > 0) {
    echo "Осталось: $count\n";
    $count--;
}

Если условие изначально ложно, тело не выполняется ни разу.

Процесс запускается следующим образом. Сначала система вычисляет значение условия $count > 0. В примере переменная $count равна 3, поэтому условие возвращает истину. Скрипт переходит к выполнению тела цикла: выводит текст «Осталось: 3» и уменьшает переменную $count на единицу (становится 2).

После завершения тела цикла выполнение возвращается к началу структуры. Система снова проверяет условие $count > 0. Текущее значение 2 удовлетворяет условию, поэтому тело выполняется повторно. Выводится «Осталось: 2», счетчик уменьшается до 1. Процесс повторяется еще раз: вывод «Осталось: 1», счетчик становится 0.

При следующей проверке условие $count > 0 оказывается ложным, так как 0 не больше 0. Цикл немедленно завершается, и управление передается инструкции, следующей после закрывающей фигурной скобки. Текст «Осталось: 0» никогда не выводится, так как проверка происходит до входа в блок.

Ключевой особенностью цикла while является то, что условие проверяется до первой итерации. Если при первом запуске условие оказывается ложным, тело цикла не выполнится ни единого раза. Это отличает его от цикла do...while, где тело гарантированно выполняется хотя бы один раз.

Пример отсутствия выполнения:

$active = false;

while ($active) {
    echo "Этот текст не появится";
    // ... другие действия
}
echo "Цикл завершился сразу";

В данном случае переменная $active имеет значение false. Проверка условия $active возвращает ложь сразу же при старте. Блок кода пропускается полностью. Выполнение программы продолжается со строки после цикла, выводя сообщение о том, что цикл завершился сразу.

Это свойство делает конструкцию while идеальной для защиты от выполнения кода в недопустимых состояниях. Например, можно запустить цикл обработки очереди только тогда, когда очередь не пуста. Если очередь пуста с самого начала, цикл просто игнорируется без лишних действий.

Цикл while часто используется, когда условие выхода зависит от событий, происходящих внутри тела цикла. В отличие от цикла for, здесь нет явного счетчика в заголовке. Изменение переменной, влияющей на условие, должно происходить явно внутри блока кода.

Система будет проверять одно и то же условие бесконечно, пока скрипт не будет принудительно остановлен сервером или пользователем.

Пример бесконечного цикла:

$counter = 5;

while ($counter > 0) {
    echo "Бесконечность: $counter\n";
    // Отсутствует строка $counter--;
}

Здесь переменная $counter всегда равна 5. Условие $counter > 0 всегда истинно. Тело цикла выполняется бесконечно, выводя одну и ту же строку до исчерпания ресурсов памяти или времени выполнения.

Для предотвращения таких ситуаций необходимо гарантировать, что внутри тела цикла существует инструкция, изменяющая состояние переменных, участвующих в условии проверки.

Широкое применение цикл while находит при работе с внешними источниками данных, размер которых неизвестен заранее. Типичные сценарии включают чтение строк из файла, обработку входящих запросов или перебор элементов массива до достижения конца.

Пример чтения файла построчно:

$file = fopen('Данные.txt', 'r');

while (($line = fgets($file)) !== false) {
    echo "Обработана строка: $line\n";
    processLine($line);
}

fclose($file);

Функция fgets считывает следующую строку из файла и присваивает ее переменной $line. Если файл закончился, функция возвращает false. Условие цикла проверяет результат: пока строка не равна false, цикл продолжается. Как только конец файла достигнут, условие становится ложным, и чтение прекращается.

Такой подход позволяет обрабатывать файлы любого размера, не загружая их целиком в память. Цикл работает порционно, читая и обрабатывая данные по мере поступления.

---

Цикл do-while

Цикл do-while гарантирует выполнение тела хотя бы один раз.

Цикл do-while представляет собой механизм повторения выполнения блока кода, который гарантирует выполнение тела цикла хотя бы один раз до первой проверки условия. Этот инструмент незаменим в сценариях, где действие должно произойти обязательно перед тем, как система получит возможность оценить результат и решить, продолжать ли работу. Алгоритм работы строится на последовательности: сначала выполняется код, затем проверяется условие, и только при истинности условия цикл повторяется.

Синтаксис конструкции начинается с ключевого слова do, за которым следует блок кода в фигурных скобках. После закрывающей скобки идет ключевое слово while, за которым следует условие в круглых скобках. Завершается вся конструкция обязательной точкой с запятой.

do {
    // тело цикла
} while (<условие>);

$input = '';
do {
    $input = readline('Введите число от 1 до 10: ');
    $number = (int)$input;
} while ($number < 1 || $number > 10);

В этом примере переменная $input изначально пуста. Цикл начинает работу: программа выводит приглашение ввести число, пользователь вводит значение, которое преобразуется в целое число $number. Сразу после этого выполняется проверка условия $number < 1 || $number > 10.

Если пользователь ввел число 5, условие ложно (5 не меньше 1 и не больше 10). Цикл завершается, и программа переходит к дальнейшей обработке числа 5.

Если пользователь ввел число 15, условие истинно (15 больше 10). Управление возвращается в начало блока do. Скрипт снова выводит приглашение и ждет нового ввода. Процесс повторяется до тех пор, пока пользователь не введет число в допустимом диапазоне.

Такой подход обеспечивает защиту от отсутствия ввода и гарантирует, что программа получит данные перед продолжением работы.

Обязательна точка с запятой после while. Синтаксис цикла do-while требует строгого соблюдения правил пунктуации. Точка с запятой (;) ставится после закрывающей скобки условия в конце конструкции while (...).

} while ($condition); // Точка с запятой здесь обязательна

Отсутствие этой точки приводит к синтаксической ошибке интерпретатора PHP. Система ожидает завершения выражения, но встречает конец строки или другую инструкцию без разделителя. Это распространенная ошибка новичков, так как в цикле for точка с запятой стоит внутри скобок, а в цикле while она отсутствует вовсе. В случае do-while точка с запятой служит окончанием всей конструкции цикла.

Пример ошибки:

do {
    echo "Ошибка";
} while ($x < 10) // Ошибка: нет точки с запятой

Правильный вариант:

do {
    echo "Верно";
} while ($x < 10);

Процесс запуска происходит следующим образом. Система сразу переходит к выполнению тела цикла, игнорируя предварительную проверку условий. Код внутри блока выполняется полностью. Только после завершения всех инструкций тела управления передается следующая часть конструкции — проверка условия после слова while. Если условие возвращает истину, управление возвращается в начало блока do, и тело выполняется снова. Если условие ложно, цикл завершается, и выполнение продолжается со следующей инструкции программы.

Ключевым отличием от цикла while является отсутствие возможности пропустить тело цикла при старте. В цикле while условие проверяется перед первым входом, поэтому если оно изначально ложно, код не выполнится ни разу. В цикле do-while тело гарантированно выполнится минимум один раз, независимо от начального состояния переменных.

Типичный сценарий применения этого цикла — получение корректных данных от пользователя. Программа должна запросить ввод, обработать его, а затем проверить, соответствует ли он требованиям. Если требования не выполнены, запрос повторяется.

Основное различие между циклами заключается в моменте проверки условия. Цикл while проверяет условие перед каждой итерацией, включая первую. Это означает, что тело может не выполниться вообще. Цикл do-while проверяет условие после каждой итерации. Это означает, что тело выполнится всегда хотя бы один раз.

Как и в других типах циклов, существует риск создания бесконечного цикла, если условие никогда не станет ложным. В цикле do-while это особенно опасно, так как тело выполнится хотя бы один раз, и если логика изменения переменных внутри тела не приведет к изменению условия, процесс зациклится навсегда.

---

Цикл foreach

Цикл foreach предназначен для итерации по массивам и объектам.

Цикл foreach представляет собой специализированный механизм перебора элементов коллекций в PHP. Этот инструмент создан исключительно для работы с массивами и объектами, реализующими интерфейс Traversable. Он автоматизирует процесс извлечения данных, устраняя необходимость в ручном управлении индексами или счетчиками. Алгоритм работы строится на последовательном доступе к каждому элементу коллекции до тех пор, пока не будут обработаны все доступные значения.

Синтаксис цикла начинается с ключевого слова foreach, за которым следует имя массива в фигурных скобках, ключевое слово as и имя переменной для текущего элемента. В этой конструкции переменная-счетчик не требуется, так как цикл сам управляет переходом от одного элемента к следующему.

По значениям:

foreach ($<массив> as $<элемент>) {
    // обработка элемента
}

При каждом проходе цикла система присваивает текущему элементу массива значение, которое копируется в указанную переменную. Эта переменная доступна только внутри тела цикла. После завершения обработки элемента управление передается следующему элементу. Если массив пуст, тело цикла не выполнится ни разу.

По ключам и значениям:

foreach ($<массив> as $<ключ> => $<значение>) {
    // обработка пары
}

Пример перебора списка оценок:

$scores = ['Анна' => 95, 'Борис' => 87];
foreach ($scores as $name => $score) {
    echo "$name: $score\n";
}

В данном примере циклу передаются только числовые значения (95 и 87). Ключи массива («Анна», «Борис») игнорируются. Результатом работы будет вывод двух строк с оценками без имен студентов.

Для доступа к идентификаторам элементов используется расширенный синтаксис с оператором стрелки =>. В этом случае первая переменная принимает значение ключа, а вторая — значение элемента. Это позволяет обрабатывать пары «ключ-значение» одновременно.

Этот подход незаменим при работе с ассоциативными массивами, где ключи имеют смысловую нагрузку (имена, коды, идентификаторы). Система автоматически перебирает все пары, сохраняя связь между именем элемента и его данными.

Пример использования с именами студентов:

$scores = ['Анна' => 95, 'Борис' => 87];
foreach ($scores as $name => $score) {
    echo "$name: $score\n";
}

Здесь переменная $name получает значение ключа ('Анна', затем 'Борис'), а переменная $score — соответствующее значение (95, затем 87). Результатом является вывод полного списка с именами и оценками. Порядок обхода соответствует порядку добавления элементов в массив.

Модификация через ссылку:

foreach ($<массив> as &$<элемент>) {
    $<элемент> = <новое_значение>;
}
unset($<элемент>); // обязательный сброс ссылки

По умолчанию цикл foreach работает с копией значения элемента. Изменение переменной внутри тела цикла не влияет на исходный массив. Чтобы изменить данные в самом массиве, необходимо использовать оператор ссылки &. При объявлении переменной со знаком амперсанд (&) она становится ссылкой на оригинальный элемент, а не его копией.

$prices = [100, 200];
foreach ($prices as &$price) {
    $price *= 1.1;
}
unset($price);

В этом режиме изменение значения переменной сразу отражается в массиве. Это позволяет применять операции трансформации ко всем элементам без необходимости обращения к ним по индексам.

После выполнения этого кода массив $prices будет содержать значения 110 и 220. Переменная $price была ссылкой на каждый элемент по очереди, поэтому изменения сохранились в исходной структуре.

---

Управление потоком выполнения

Операторы break и continue

Оператор break прекращает выполнение цикла.
Оператор continue переходит к следующей итерации.

Оба принимают необязательный числовой аргумент — количество уровней вложенности для выхода/пропуска:

for ($i = 0; $i < 3; $i++) {
    for ($j = 0; $j < 3; $j++) {
        if ($i === 1 && $j === 1) {
            break 2; // выход из обоих циклов
        }
        echo "$i,$j ";
    }
}

---

Генераторы и yield

Генераторы позволяют создавать ленивые последовательности без загрузки всех данных в память.

function xrange($start, $end) {
    for ($i = $start; $i <= $end; $i++) {
        yield $i;
    }
}

foreach (xrange(1, 5) as $n) {
    echo "$n ";
}

Генератор с ключами:

yield $key => $value;

Генератор можно итерировать только один раз. Для повторного использования вызывается заново.

---

Рекомендации

• Используйте === и !== для строгого сравнения.
• Предпочитайте match вместо switch при выборе значения.
• Избегайте модификации массива внутри foreach.
• Всегда вызывайте unset() после foreach (&$ref).
• Валидируйте входные данные до условий.
• Не используйте and/or — их приоритет ниже ожидаемого.

---